home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / lib-old / fmt.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  19KB  |  698 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import string
  5. import Para
  6.  
  7. class NullBackEnd:
  8.     
  9.     def __init__(self):
  10.         pass
  11.  
  12.     
  13.     def addpara(self, p):
  14.         pass
  15.  
  16.     
  17.     def bgn_anchor(self, id):
  18.         pass
  19.  
  20.     
  21.     def end_anchor(self, id):
  22.         pass
  23.  
  24.  
  25.  
  26. class SavingBackEnd(NullBackEnd):
  27.     
  28.     def __init__(self):
  29.         self.paralist = []
  30.  
  31.     
  32.     def addpara(self, p):
  33.         self.paralist.append(p)
  34.  
  35.     
  36.     def hitcheck(self, h, v):
  37.         hits = []
  38.         for p in self.paralist:
  39.             if v <= v:
  40.                 pass
  41.             elif v <= p.bottom:
  42.                 for id in p.hitcheck(h, v):
  43.                     if id not in hits:
  44.                         hits.append(id)
  45.                         continue
  46.                 
  47.         
  48.         return hits
  49.  
  50.     
  51.     def extract(self):
  52.         text = ''
  53.         for p in self.paralist:
  54.             text = text + p.extract()
  55.         
  56.         return text
  57.  
  58.     
  59.     def extractpart(self, long1, long2):
  60.         if long1 > long2:
  61.             long1 = long2
  62.             long2 = long1
  63.         
  64.         (para1, pos1) = long1
  65.         (para2, pos2) = long2
  66.         text = ''
  67.         while para1 < para2:
  68.             ptext = self.paralist[para1].extract()
  69.             text = text + ptext[pos1:]
  70.             pos1 = 0
  71.             para1 = para1 + 1
  72.         ptext = self.paralist[para2].extract()
  73.         return text + ptext[pos1:pos2]
  74.  
  75.     
  76.     def whereis(self, d, h, v):
  77.         total = 0
  78.         for i in range(len(self.paralist)):
  79.             p = self.paralist[i]
  80.             result = p.whereis(d, h, v)
  81.             if result is not None:
  82.                 return (i, result)
  83.                 continue
  84.         
  85.  
  86.     
  87.     def roundtowords(self, long1, long2):
  88.         (i, offset) = long1
  89.         text = self.paralist[i].extract()
  90.         while offset > 0 and text[offset - 1] != ' ':
  91.             offset = offset - 1
  92.         long1 = (i, offset)
  93.         (i, offset) = long2
  94.         text = self.paralist[i].extract()
  95.         n = len(text)
  96.         while offset < n - 1 and text[offset] != ' ':
  97.             offset = offset + 1
  98.         long2 = (i, offset)
  99.         return (long1, long2)
  100.  
  101.     
  102.     def roundtoparagraphs(self, long1, long2):
  103.         long1 = (long1[0], 0)
  104.         long2 = (long2[0], len(self.paralist[long2[0]].extract()))
  105.         return (long1, long2)
  106.  
  107.  
  108.  
  109. class WritingBackEnd(NullBackEnd):
  110.     
  111.     def __init__(self, d, width):
  112.         self.d = d
  113.         self.width = width
  114.         self.lineno = 0
  115.  
  116.     
  117.     def addpara(self, p):
  118.         self.lineno = p.render(self.d, 0, self.lineno, self.width)
  119.  
  120.  
  121.  
  122. class BaseFormatter:
  123.     
  124.     def __init__(self, d, b):
  125.         self.d = d
  126.         self.b = b
  127.         self.leftindent = 0
  128.         self.just = 'l'
  129.         self.font = None
  130.         self.blanklines = 0
  131.         self.space = d.textwidth(' ')
  132.         self.line = d.lineheight()
  133.         self.ascent = d.baseline()
  134.         self.descent = self.line - self.ascent
  135.         self.n_space = self.space
  136.         self.para = None
  137.         self.nospace = 1
  138.         self.nextfont = None
  139.  
  140.     
  141.     def newpara(self):
  142.         return Para.Para()
  143.  
  144.     
  145.     def setfont(self, font):
  146.         if font is None:
  147.             return None
  148.         
  149.         self.font = self.nextfont = font
  150.         d = self.d
  151.         d.setfont(font)
  152.         self.space = d.textwidth(' ')
  153.         self.line = d.lineheight()
  154.         self.ascent = d.baseline()
  155.         self.descent = self.line - self.ascent
  156.  
  157.     
  158.     def setleftindent(self, nspaces):
  159.         self.leftindent = int(self.n_space * nspaces)
  160.         if self.para:
  161.             hang = self.leftindent - self.para.indent_left
  162.             if hang > 0 and self.para.getlength() <= hang:
  163.                 self.para.makehangingtag(hang)
  164.                 self.nospace = 1
  165.             else:
  166.                 self.flush()
  167.         
  168.  
  169.     
  170.     def setrightindent(self, nspaces):
  171.         self.rightindent = int(self.n_space * nspaces)
  172.         if self.para:
  173.             self.para.indent_right = self.rightindent
  174.             self.flush()
  175.         
  176.  
  177.     
  178.     def setjust(self, just):
  179.         self.just = just
  180.         if self.para:
  181.             self.para.just = self.just
  182.         
  183.  
  184.     
  185.     def flush(self):
  186.         if self.para:
  187.             self.b.addpara(self.para)
  188.             self.para = None
  189.             if self.font is not None:
  190.                 self.d.setfont(self.font)
  191.             
  192.         
  193.         self.nospace = 1
  194.  
  195.     
  196.     def vspace(self, nlines):
  197.         self.flush()
  198.         if nlines > 0:
  199.             self.para = self.newpara()
  200.             tuple = (None, '', 0, 0, 0, int(nlines * self.line), 0)
  201.             self.para.words.append(tuple)
  202.             self.flush()
  203.             self.blanklines = self.blanklines + nlines
  204.         
  205.  
  206.     
  207.     def needvspace(self, nlines):
  208.         self.flush()
  209.         if nlines > self.blanklines:
  210.             self.vspace(nlines - self.blanklines)
  211.         
  212.  
  213.     
  214.     def addword(self, text, space):
  215.         if self.nospace and not text:
  216.             return None
  217.         
  218.         self.nospace = 0
  219.         self.blanklines = 0
  220.         if not self.para:
  221.             self.para = self.newpara()
  222.             self.para.indent_left = self.leftindent
  223.             self.para.just = self.just
  224.             self.nextfont = self.font
  225.         
  226.         space = int(space * self.space)
  227.         self.para.words.append((self.nextfont, text, self.d.textwidth(text), space, space, self.ascent, self.descent))
  228.         self.nextfont = None
  229.  
  230.     
  231.     def bgn_anchor(self, id):
  232.         if not self.para:
  233.             self.nospace = 0
  234.             self.addword('', 0)
  235.         
  236.         self.para.bgn_anchor(id)
  237.  
  238.     
  239.     def end_anchor(self, id):
  240.         if not self.para:
  241.             self.nospace = 0
  242.             self.addword('', 0)
  243.         
  244.         self.para.end_anchor(id)
  245.  
  246.  
  247.  
  248. class NullMeasurer:
  249.     
  250.     def __init__(self):
  251.         pass
  252.  
  253.     
  254.     def setfont(self, font):
  255.         pass
  256.  
  257.     
  258.     def textwidth(self, text):
  259.         return len(text)
  260.  
  261.     
  262.     def lineheight(self):
  263.         return 1
  264.  
  265.     
  266.     def baseline(self):
  267.         return 0
  268.  
  269.  
  270.  
  271. class FileWriter:
  272.     
  273.     def __init__(self, fp):
  274.         self.fp = fp
  275.         (self.lineno, self.colno) = (0, 0)
  276.  
  277.     
  278.     def setfont(self, font):
  279.         pass
  280.  
  281.     
  282.     def text(self, .2, str):
  283.         (h, v) = .2
  284.         if not str:
  285.             return None
  286.         
  287.         if '\n' in str:
  288.             raise ValueError, "can't write \\n"
  289.         
  290.         while self.lineno < v:
  291.             self.fp.write('\n')
  292.             self.colno = 0
  293.             self.lineno = self.lineno + 1
  294.         while self.lineno > v:
  295.             self.fp.write('\x1b[A')
  296.             self.lineno = self.lineno - 1
  297.         if self.colno < h:
  298.             self.fp.write(' ' * (h - self.colno))
  299.         elif self.colno > h:
  300.             self.fp.write('\x08' * (self.colno - h))
  301.         
  302.         self.colno = h
  303.         self.fp.write(str)
  304.         self.colno = h + len(str)
  305.  
  306.  
  307.  
  308. class NullFormatter(BaseFormatter):
  309.     
  310.     def __init__(self):
  311.         d = NullMeasurer()
  312.         b = NullBackEnd()
  313.         BaseFormatter.__init__(self, d, b)
  314.  
  315.  
  316.  
  317. class WritingFormatter(BaseFormatter):
  318.     
  319.     def __init__(self, fp, width):
  320.         dm = NullMeasurer()
  321.         dw = FileWriter(fp)
  322.         b = WritingBackEnd(dw, width)
  323.         BaseFormatter.__init__(self, dm, b)
  324.         self.blanklines = 1
  325.  
  326.     
  327.     def needvspace(self, nlines):
  328.         BaseFormatter.needvspace(self, min(1, nlines))
  329.  
  330.  
  331.  
  332. class FunnyFormatter(WritingFormatter):
  333.     
  334.     def flush(self):
  335.         if self.para:
  336.             finalize(self.para)
  337.         
  338.         WritingFormatter.flush(self)
  339.  
  340.  
  341. openchar = {
  342.     'b': '*',
  343.     'i': '_',
  344.     'u': '_',
  345.     'q': '`',
  346.     'B': '*',
  347.     'I': '_',
  348.     'U': '_',
  349.     'Q': '`' }
  350. closechar = {
  351.     'b': '*',
  352.     'i': '_',
  353.     'u': '_',
  354.     'q': "'",
  355.     'B': '*',
  356.     'I': '_',
  357.     'U': '_',
  358.     'Q': "'" }
  359.  
  360. def finalize(para):
  361.     oldfont = curfont = 'r'
  362.     para.words.append(('r', '', 0, 0, 0, 0))
  363.     for i in range(len(para.words)):
  364.         (fo, te, wi) = para.words[i][:3]
  365.         if fo is not None:
  366.             curfont = fo
  367.         
  368.         if curfont != oldfont:
  369.             if closechar.has_key(oldfont):
  370.                 c = closechar[oldfont]
  371.                 j = i - 1
  372.                 while j > 0 and para.words[j][1] == '':
  373.                     j = j - 1
  374.                 (fo1, te1, wi1) = para.words[j][:3]
  375.                 te1 = te1 + c
  376.                 wi1 = wi1 + len(c)
  377.                 para.words[j] = (fo1, te1, wi1) + para.words[j][3:]
  378.             
  379.             if openchar.has_key(curfont) and te:
  380.                 c = openchar[curfont]
  381.                 te = c + te
  382.                 wi = len(c) + wi
  383.                 para.words[i] = (fo, te, wi) + para.words[i][3:]
  384.             
  385.             if te:
  386.                 oldfont = curfont
  387.             else:
  388.                 oldfont = 'r'
  389.         
  390.         if curfont in string.uppercase:
  391.             te = string.upper(te)
  392.             para.words[i] = (fo, te, wi) + para.words[i][3:]
  393.             continue
  394.     
  395.     del para.words[-1]
  396.  
  397.  
  398. class StdwinBackEnd(SavingBackEnd):
  399.     
  400.     def __init__(self, window, drawnow):
  401.         self.window = window
  402.         self.drawnow = drawnow
  403.         self.width = window.getwinsize()[0]
  404.         self.selection = None
  405.         self.height = 0
  406.         window.setorigin(0, 0)
  407.         window.setdocsize(0, 0)
  408.         self.d = window.begindrawing()
  409.         SavingBackEnd.__init__(self)
  410.  
  411.     
  412.     def finish(self):
  413.         self.d.close()
  414.         self.d = None
  415.         self.window.setdocsize(0, self.height)
  416.  
  417.     
  418.     def addpara(self, p):
  419.         self.paralist.append(p)
  420.         if self.drawnow:
  421.             self.height = p.render(self.d, 0, self.height, self.width)
  422.         else:
  423.             p.layout(self.width)
  424.             p.left = 0
  425.             p.top = self.height
  426.             p.right = self.width
  427.             p.bottom = self.height + p.height
  428.             self.height = p.bottom
  429.  
  430.     
  431.     def resize(self):
  432.         self.window.change((0, 0), (self.width, self.height))
  433.         self.width = self.window.getwinsize()[0]
  434.         self.height = 0
  435.         for p in self.paralist:
  436.             p.layout(self.width)
  437.             p.left = 0
  438.             p.top = self.height
  439.             p.right = self.width
  440.             p.bottom = self.height + p.height
  441.             self.height = p.bottom
  442.         
  443.         self.window.change((0, 0), (self.width, self.height))
  444.         self.window.setdocsize(0, self.height)
  445.  
  446.     
  447.     def redraw(self, area):
  448.         d = self.window.begindrawing()
  449.         (left, top) = ()
  450.         (right, bottom) = area
  451.         d.erase(area)
  452.         d.cliprect(area)
  453.         for p in self.paralist:
  454.             if top < p.bottom and p.top < bottom:
  455.                 v = p.render(d, p.left, p.top, p.right)
  456.                 continue
  457.         
  458.         if self.selection:
  459.             self.invert(d, self.selection)
  460.         
  461.         d.close()
  462.  
  463.     
  464.     def setselection(self, new):
  465.         if new:
  466.             (long1, long2) = new
  467.             pos1 = long1[:3]
  468.             pos2 = long2[:3]
  469.             new = (pos1, pos2)
  470.         
  471.         if new != self.selection:
  472.             d = self.window.begindrawing()
  473.             if self.selection:
  474.                 self.invert(d, self.selection)
  475.             
  476.             if new:
  477.                 self.invert(d, new)
  478.             
  479.             d.close()
  480.             self.selection = new
  481.         
  482.  
  483.     
  484.     def getselection(self):
  485.         return self.selection
  486.  
  487.     
  488.     def extractselection(self):
  489.         if self.selection:
  490.             (a, b) = self.selection
  491.             return self.extractpart(a, b)
  492.         else:
  493.             return None
  494.  
  495.     
  496.     def invert(self, d, region):
  497.         (long1, long2) = region
  498.         if long1 > long2:
  499.             long1 = long2
  500.             long2 = long1
  501.         
  502.         (para1, pos1) = long1
  503.         (para2, pos2) = long2
  504.         while para1 < para2:
  505.             self.paralist[para1].invert(d, pos1, None)
  506.             pos1 = None
  507.             para1 = para1 + 1
  508.         self.paralist[para2].invert(d, pos1, pos2)
  509.  
  510.     
  511.     def search(self, prog):
  512.         import re as re
  513.         import string
  514.         if type(prog) is type(''):
  515.             prog = re.compile(string.lower(prog))
  516.         
  517.         if self.selection:
  518.             iold = self.selection[0][0]
  519.         else:
  520.             iold = -1
  521.         hit = None
  522.         for i in range(len(self.paralist)):
  523.             if (i == iold or i < iold) and hit:
  524.                 continue
  525.             
  526.             p = self.paralist[i]
  527.             text = string.lower(p.extract())
  528.             match = prog.search(text)
  529.             if match:
  530.                 (a, b) = match.group(0)
  531.                 long1 = (i, a)
  532.                 long2 = (i, b)
  533.                 hit = (long1, long2)
  534.                 if i > iold:
  535.                     break
  536.                 
  537.             i > iold
  538.         
  539.         if hit:
  540.             self.setselection(hit)
  541.             i = hit[0][0]
  542.             p = self.paralist[i]
  543.             self.window.show((p.left, p.top), (p.right, p.bottom))
  544.             return 1
  545.         else:
  546.             return 0
  547.  
  548.     
  549.     def showanchor(self, id):
  550.         for i in range(len(self.paralist)):
  551.             p = self.paralist[i]
  552.             if p.hasanchor(id):
  553.                 long1 = (i, 0)
  554.                 long2 = (i, len(p.extract()))
  555.                 hit = (long1, long2)
  556.                 self.setselection(hit)
  557.                 self.window.show((p.left, p.top), (p.right, p.bottom))
  558.                 break
  559.                 continue
  560.         
  561.  
  562.  
  563.  
  564. class GLFontCache:
  565.     
  566.     def __init__(self):
  567.         self.reset()
  568.         self.setfont('')
  569.  
  570.     
  571.     def reset(self):
  572.         self.fontkey = None
  573.         self.fonthandle = None
  574.         self.fontinfo = None
  575.         self.fontcache = { }
  576.  
  577.     
  578.     def close(self):
  579.         self.reset()
  580.  
  581.     
  582.     def setfont(self, fontkey):
  583.         if fontkey == '':
  584.             fontkey = 'Times-Roman 12'
  585.         elif ' ' not in fontkey:
  586.             fontkey = fontkey + ' 12'
  587.         
  588.         if fontkey == self.fontkey:
  589.             return None
  590.         
  591.         if self.fontcache.has_key(fontkey):
  592.             handle = self.fontcache[fontkey]
  593.         else:
  594.             import string
  595.             i = string.index(fontkey, ' ')
  596.             name = fontkey[:i]
  597.             sizestr = fontkey[i:]
  598.             size = eval(sizestr)
  599.             key1 = name + ' 1'
  600.             key = name + ' ' + `size`
  601.             if self.fontcache.has_key(key):
  602.                 handle = self.fontcache[key]
  603.             elif self.fontcache.has_key(key1):
  604.                 handle = self.fontcache[key1]
  605.             else:
  606.                 import fm as fm
  607.                 handle = fm.findfont(name)
  608.                 self.fontcache[key1] = handle
  609.             handle = handle.scalefont(size)
  610.             self.fontcache[fontkey] = self.fontcache[key] = handle
  611.         self.fontkey = fontkey
  612.         if self.fonthandle != handle:
  613.             self.fonthandle = handle
  614.             self.fontinfo = handle.getfontinfo()
  615.             handle.setfont()
  616.         
  617.  
  618.  
  619.  
  620. class GLMeasurer(GLFontCache):
  621.     
  622.     def textwidth(self, text):
  623.         return self.fonthandle.getstrwidth(text)
  624.  
  625.     
  626.     def baseline(self):
  627.         return self.fontinfo[6] - self.fontinfo[3]
  628.  
  629.     
  630.     def lineheight(self):
  631.         return self.fontinfo[6]
  632.  
  633.  
  634.  
  635. class GLWriter(GLFontCache):
  636.     
  637.     def text(self, .2, text):
  638.         (h, v) = .2
  639.         import gl as gl
  640.         import fm
  641.         gl.cmov2i(h, v + self.fontinfo[6] - self.fontinfo[3])
  642.         fm.prstr(text)
  643.  
  644.     
  645.     def setfont(self, fontkey):
  646.         oldhandle = self.fonthandle
  647.         GLFontCache.setfont(fontkey)
  648.         if self.fonthandle != oldhandle:
  649.             handle.setfont()
  650.         
  651.  
  652.  
  653.  
  654. class GLMeasurerWriter(GLMeasurer, GLWriter):
  655.     pass
  656.  
  657.  
  658. class GLBackEnd(SavingBackEnd):
  659.     
  660.     def __init__(self, wid):
  661.         import gl
  662.         gl.winset(wid)
  663.         self.wid = wid
  664.         self.width = gl.getsize()[1]
  665.         self.height = 0
  666.         self.d = GLMeasurerWriter()
  667.         SavingBackEnd.__init__(self)
  668.  
  669.     
  670.     def finish(self):
  671.         pass
  672.  
  673.     
  674.     def addpara(self, p):
  675.         self.paralist.append(p)
  676.         self.height = p.render(self.d, 0, self.height, self.width)
  677.  
  678.     
  679.     def redraw(self):
  680.         import gl
  681.         gl.winset(self.wid)
  682.         width = gl.getsize()[1]
  683.         if width != self.width:
  684.             setdocsize = 1
  685.             self.width = width
  686.             for p in self.paralist:
  687.                 p.top = None
  688.                 p.bottom = None
  689.             
  690.         
  691.         d = self.d
  692.         v = 0
  693.         for p in self.paralist:
  694.             v = p.render(d, 0, v, width)
  695.         
  696.  
  697.  
  698.